home *** CD-ROM | disk | FTP | other *** search
/ Whiteline: Alpha / Whiteline Alpha.iso / tex / tools / dvi / treiber.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-09-22  |  6.6 KB  |  329 lines
  1. #include <signal.h>
  2. #include <atarierr.h>
  3.  
  4. #ifdef __GNUC__
  5. #include <fcntl.h>
  6. #include <ioctl.h>
  7. #include <osbind.h>
  8. #endif
  9.  
  10. #ifdef __TURBOC__
  11. #include "mintbind.h"    /* Geht seltsamerweise nur mit der eigenen Version */
  12. #endif
  13.  
  14. #include <stdlib.h>
  15. #include <string.h>
  16.  
  17. #include "treiber.h"
  18.  
  19. #define FALSE 0
  20. #define TRUE 1
  21.  
  22. #define _SHOW_PRT_    /* Fortgang anzeigen */
  23.  
  24. /********************************************************************/
  25. /* Externe routinen in Assembler (FAST_DVI.S) */
  26. extern long    prn_byte( char *ptr, long byte );
  27. extern void    exstall( void );
  28.  
  29. extern volatile long    old_vec;
  30. /* 22.1.93 */
  31.  
  32. /********************************************************************/
  33.  
  34. /* Pufferspeicher */
  35. static char    *puffer, *druck_puffer;
  36. long    max_puffer_laenge = 8192L;    /* Kann vom Programm modifiziert werden */
  37. static long    puffer_laenge = 0L;
  38.  
  39. /* Shared Memory */
  40. char                shm_name[128];
  41. static int    shm;
  42. static char    *memory;
  43.  
  44. /* Name des temporären Files */
  45. char                 tmp_file[256];
  46. long                MiNT;
  47.  
  48. #ifdef _SHOW_PRT_
  49. char    *disp_status="\033Hp";
  50. char    *char_status="/-\\|";
  51. char    rot_status;
  52. #endif
  53.  
  54. /********************************************************************/
  55. /* Einige Routinen zum Druck */
  56.  
  57.  
  58. void    disp_wait( void )
  59. {
  60.     while(  old_vec!=0L  ||  Bcostat(0)==0  )
  61.     {
  62.         (void)Fselect( 500, 0L, 0L, 0L );
  63. #ifdef _SHOW_PRT_
  64.         disp_status[2] = char_status[rot_status++];
  65.         rot_status &= 3;
  66.         Cconws( disp_status );
  67. #endif
  68.     }
  69. }
  70.  
  71.  
  72.     /* Gibt Puffer aus (SCHNELL!!) */
  73. void    flush_block( void )
  74. {
  75.     Psignal( SIGINT, SIG_DFL );
  76.     Psignal( SIGTERM, SIG_DFL );
  77.     if(  puffer_laenge>0  )
  78.     {
  79.         disp_wait();
  80.         memcpy( druck_puffer, puffer, puffer_laenge );
  81.         prn_byte( druck_puffer, puffer_laenge );
  82.     }
  83.     puffer_laenge = 0;
  84.     disp_wait();
  85. }
  86. /* 23.1.93 */
  87.  
  88.  
  89.  
  90.     /* Gibt an Spooler aus (SCHNELL!!) */
  91. long    print_block( long laenge, char *blk )
  92. {
  93.     if(  laenge+puffer_laenge>max_puffer_laenge  )
  94.     {
  95.         disp_wait();
  96.         if(  puffer_laenge>0  )
  97.         {
  98.             memcpy( druck_puffer, puffer, puffer_laenge );
  99.             prn_byte( druck_puffer, puffer_laenge );
  100.         }
  101.         puffer_laenge = 0L;
  102.     }
  103.  
  104.         /* Zu lang... */
  105.     if(  laenge>max_puffer_laenge  )
  106.     {
  107.         prn_byte( blk, laenge );
  108.         disp_wait();
  109.     }
  110.     else
  111.     {
  112.         memcpy( puffer+puffer_laenge, blk, laenge );
  113.         puffer_laenge += laenge;
  114.     }
  115.     return laenge;
  116. }
  117. /* 22.1.93 */
  118.  
  119.  
  120.  
  121. /* Versucht Drucker zu Öffnen und zu Verriegeln! */ 
  122. int    open_printer( void )
  123. {
  124.     int devh=5;
  125.  
  126.     puffer = Malloc( max_puffer_laenge );    /* Speicher holen */
  127.     druck_puffer = Malloc( max_puffer_laenge );
  128.     if(  druck_puffer<=0  ||  puffer<=0  )
  129.         return -1;
  130.  
  131.     if(  MiNT  )
  132.     {    /* Druckersemaphore bekommen! (Wird bei Beendigung automatisch frei) */
  133.         devh = (int)Psemaphore( 0, 0x50524E3AL /*PRN:*/, -1 /*Kein Timeout*/ );
  134.         if(  devh!=0  )
  135.             Psemaphore( 2, 0x50524E3AL /*PRN:*/, -1 /*Kein Timeout*/ );
  136.     }
  137.  
  138. #ifdef _SHOW_PRT_
  139.     disp_status[2] = '|';
  140.     Cconws( disp_status );
  141. #endif
  142.  
  143.     if(  MiNT  )
  144.     {
  145.         while(  (devh=(int)Fopen( "U:\\dev\\prn", O_WRONLY ))==EACCDN  )
  146.             (void)Fselect( 100, 0L, 0L, 0L );
  147.         Psignal( SIGINT, (long)exstall );
  148.         Psignal( SIGTERM, (long)exstall );
  149.     }
  150.     return devh;
  151. }
  152. /* 6.2.93 */
  153.  
  154.  
  155.  
  156. int        get_tempfile( char *drucker_ext )
  157. {
  158.     char    *p;
  159.     long    lz;
  160.     int        th;
  161.  
  162.     if(  tmp_file[0]==0  )
  163.     {
  164.         /* In temporäre Datei drucken! */
  165.         if(  (p=getenv("TMPDIR"))!=0L  )
  166.         {
  167.             strcat( tmp_file, p );
  168.             if(  p[strlen(p-1)]!='\\'  )
  169.                 strcat( tmp_file, "\\" );
  170.         }
  171.         strcat( tmp_file, "print00." );
  172.         lz = strlen(tmp_file)-2;
  173.         strcat( tmp_file, drucker_ext );
  174.         while(  (th=(int)Fopen(tmp_file,O_RDWR))>0  )
  175.         {
  176.             Fclose( th );
  177.             if(  (++(tmp_file[lz]))=='9'  )
  178.             {
  179.                 ++(tmp_file[lz-1]);
  180.                 tmp_file[lz] = '0';
  181.             }
  182.         }
  183.         th = -32;
  184.     }
  185.     else
  186.     {
  187.         th = (int)Fopen( tmp_file, O_WRONLY|O_APPEND|O_CREAT );
  188.         if(  th>0  )
  189.             Fseek( 0L, th, 2 );
  190.     }
  191.     if(  th<=-32  )
  192.         th = (int)Fcreate( tmp_file, 0 );
  193. #ifdef _SHOW_PRT_
  194.     if(  th>=0  )
  195.         Cconws( disp_status );
  196. #endif
  197.     return th;
  198. }
  199. /* 6.2.93 */
  200.  
  201.  
  202.  
  203. /********************************************************************/
  204. /* Routinen für Optimierung */
  205.  
  206.  
  207. /* Ist diese Zeile Leerzeile? */
  208. int    ist_leerzeile( char *ptr, long offset )
  209. {
  210.     long    i;
  211.     for(  i=0;  i<offset;  i++  )
  212.         if(  *ptr++!=0  )
  213.             return FALSE;
  214.     return TRUE;
  215. }
  216. /* 16.1.93 */
  217.  
  218.  
  219.  
  220. /* Sind in den nächsten #next Zeilen Zeichen? */
  221. int    ist_next_leer( char *ptr, long offset, long next )
  222. {
  223.     while(  next>0  )
  224.     {
  225.         if(  *ptr!=0  )
  226.             return FALSE;
  227.         next--;
  228.         ptr += offset;
  229.     }
  230.     return TRUE;
  231. }
  232. /* 16.1.93 */
  233.  
  234.  
  235.  
  236. /********************************************************************/
  237. /* Hauptprogramm */
  238.  
  239.  
  240. int    main( int argc, const char *argv[] )
  241. {
  242.     long    i;
  243.     int        th, devh;
  244.     extern long    CookieJar( long cooks_name );
  245.  
  246.     if(  argc<6  )
  247.     {
  248.         Cconws( "Zuwenig Argumente!\xD\xA" );
  249.         Cconws( "Richtig: shared_mem_file weite hoehe hdpi vdpi (file)\xD\xA" );
  250.         return 0;
  251.     }
  252.  
  253.     MiNT = CookieJar( 0x4D694E54L /*'MiNT'*/ );
  254.     old_vec = 0L;
  255.  
  256.         /* Diese Routine mit Parameter versehen! */
  257.         /* Es wird mit Shared Memory gearbeitet */
  258.         /* Wenn der erste Buchstabe eine Zahl ist, */
  259.         /* dann wird diese als Adresse angenommen */
  260.     strcpy( shm_name, (char *)argv[1] );
  261.     if(  shm_name[0]>='0'  &&  shm_name[0]<='9'  )
  262.     {
  263.         memory = (char *)atol( shm_name );
  264.         shm_name[0] = 0;
  265.     }
  266.     else
  267.     {
  268.         shm = (int)Fopen( shm_name, O_RDONLY );
  269.         if(  shm<0  )
  270.             return -1;
  271.         memory = (char *)Fcntl( shm, 0L, SHMGETBLK );
  272.     }
  273.     if(  memory<=0  )
  274.         return 0;
  275.  
  276.     tmp_file[0] = 0;
  277.     if(  argv[6]>0L  )
  278.         strcpy( tmp_file, argv[6] );
  279.  
  280.     th = drucke( memory, atol(argv[2]), atol(argv[3]), atol(argv[4]), atol(argv[5]) );
  281.     if(  shm_name[0]>0  )
  282.     {
  283.         Fclose( shm );
  284.         Mfree( memory );    /* so kann der Speicher wieder freigegeben werden */
  285.         Fdelete( shm_name );
  286.         shm = 0;
  287.     }
  288.     Cconws( "\033H " );
  289.  
  290.     if(  th<=0    &&  argv[6]>(char*)0    ) /* || nach && umgewandelt 6.5.93 MH */
  291.     {    /* Hier bei Fehler oder Funktion gibt selber aus! */
  292.         if(  th<0  )
  293.             Fdelete( tmp_file );
  294.         return th;
  295.     }
  296.  
  297.     /* Nur Datei erzeugen? */
  298.     if(  argv[6]>0L  )
  299.         return Fclose( th );
  300.  
  301.         /* Ab hier wird es ernst */
  302.     if(  th<=0  )
  303.         return -1;
  304.     while(  (devh=open_printer())==-1  &&  max_puffer_laenge>128  )
  305.         max_puffer_laenge /= 2L;    /* Puffer halbieren */
  306.     if(  devh<0  )
  307.         return -1;
  308.  
  309.     Fseek( 0L, th, 0 );
  310.     i = max_puffer_laenge;
  311.     do
  312.     {
  313.         disp_wait();
  314.         i = Fread( th, i, druck_puffer );
  315.         if(  i>0  )
  316.             prn_byte( druck_puffer, i );
  317.     }
  318.     while(  i>0  );
  319.  
  320.     Fclose( th );
  321.     if(  tmp_file[0]>0  )
  322.         Fdelete( tmp_file );
  323.     flush_block();
  324.     Fclose( devh );
  325.     Cconws( "\033H " );
  326.     return 1;
  327. }
  328. /* 17.1.93 */
  329.